Language/OS - Multiplatform Resource Library/LANGUAGE OS.iso/gnu/emacs.lha/emacs-19.16/info/emacs-8

GNU Info File | 1993-07-06 | 48KB | 869 lines

This is Info file ../info/emacs, produced by Makeinfo-1.54 from the
input file emacs.texi.
File: emacs,  Node: Menu Bars,  Next: Faces,  Prev: Scroll Bars,  Up: Frames
Menu Bars
=========
   By default, each Emacs frame has a menu bar at the top which you can
use to perform certain common operations.  There's no need to describe
them in detail here, as you can more easily see for yourself; also, we
may change them and add to them in subsequent Emacs versions.
   Each of the operations in the menu bar is bound to an ordinary Emacs
command which you can invoke equally well with `M-x' or with its own
key bindings.  To see the command's name and documentation, type `C-h
k' and then select the menu bar item you are interested in.
   You can turn display of menu bars on or off with `M-x menu-bar-mode'.
With no argument, this command toggles Menu Bar mode, a minor mode.
With an argument, the command turns Menu Bar mode on if the argument is
positive, off if the argument is not positive.
File: emacs,  Node: Faces,  Next: Misc X,  Prev: Menu Bars,  Up: Frames
Using Multiple Typefaces
========================
   When using Emacs with X, you can set up multiple styles of displaying
characters.  The aspects of style that you can control are the type
font, the foreground color, the background color, and whether to
underline.
   The way you control display style is by defining named "faces".
Each face can specify a type font, a foreground color, a background
color, and an underline flag; but it does not have to specify all of
them.
   The style of display used for a given character in the text is
determined by combining several faces.  Which faces to use is always set
up by Lisp programs, at present, by means of text properties and
overlays.  Any aspect of the display style that isn't specified by
overlays or text properties comes from the frame itself.
   When Transient Mark mode is enabled, the text of the region is
highlighted when the mark is active.  This uses a face named `region';
you can control the style of highlighting by changing the style of this
face with the commands below.  *Note Setting Mark::, for more
information about Transient Mark mode and activation and deactivation
of the mark.
   Here are the commands for users to change the font of a face.
`M-x set-face-font RET FACE RET FONT RET'
     Use font FONT in face FACE.
`M-x make-face-bold RET FACE RET'
     Convert face FACE to use a bold version of its current font.
`M-x make-face-italic RET FACE RET'
     Convert face FACE to use a italic version of its current font.
`M-x make-face-bold-italic RET FACE RET'
     Convert face FACE to use a bold-italic version of its current font.
`M-x make-face-unbold RET FACE RET'
     Convert face FACE to use a non-bold version of its current font.
`M-x make-face-unitalic RET FACE RET'
     Convert face FACE to use a non-italic version of its current font.
   Here are the commands for users to set the colors and underline flag
of a face:
`M-x set-face-foreground RET FACE RET COLOR RET'
     Use color COLOR for the foreground of characters in face FACE.
`M-x set-face-background RET FACE RET COLOR RET'
     Use color COLOR for the background of characters in face FACE.
`M-x set-face-underline-p RET FACE RET FLAG RET'
     Specify whether to underline characters in face FACE.
`M-x invert-face RET FACE RET'
     Swap the foreground and background colors of face FACE.
File: emacs,  Node: Misc X,  Prev: Faces,  Up: Frames
Miscellaneous X Window Features
===============================
   To iconify the selected Emacs frame, type `C-z'.  The normal meaning
of `C-z', to suspend Emacs, is not useful under a window system, so it
has a different binding in that case (the command `iconify-frame').
   To delete the selected frame, type `C-x 5 0'.
   Under X Windows, when Transient Mark mode is enabled, Emacs
highlights the region when the mark is active.  This is the main motive
for using Transient Mark mode.  To enable this mode, use the command
`M-x transient-mark-mode'.  *Note Mark::.
File: emacs,  Node: Major Modes,  Next: Indentation,  Prev: Frames,  Up: Top
Major Modes
***********
   Emacs provides many alternative "major modes", each of which
customizes Emacs for editing text of a particular sort.  The major modes
are mutually exclusive, and each buffer has one major mode at any time.
The mode line normally shows the name of the current major mode, in
parentheses (*note Mode Line::.).
   The least specialized major mode is called "Fundamental mode".  This
mode has no mode-specific redefinitions or variable settings, so that
each Emacs command behaves in its most general manner, and each option
is in its default state.  For editing any specific type of text, such
as Lisp code or English text, you should switch to the appropriate
major mode, such as Lisp mode or Text mode.
   Selecting a major mode changes the meanings of a few keys to become
more specifically adapted to the language being edited.  The ones which
are changed frequently are TAB, DEL, and LFD.  In addition, the
commands which handle comments use the mode to determine how comments
are to be delimited.  Many major modes redefine the syntactical
properties of characters appearing in the buffer.  *Note Syntax::.
   The major modes fall into three major groups.  Lisp mode (which has
several variants), C mode, Fortran mode and others are for specific
programming languages.  Text mode, Nroff mode, TeX mode and Outline
mode are for editing English text.  The remaining major modes are not
intended for use on users' files; they are used in buffers created for
specific purposes by Emacs, such as Dired mode for buffers made by Dired
(*note Dired::.), and Mail mode for buffers made by `C-x m' (*note
Sending Mail::.), and Shell mode for buffers used for communicating
with an inferior shell process (*note Interactive Shell::.).
   Most programming language major modes specify that only blank lines
separate paragraphs.  This is so that the paragraph commands remain
useful.  (*Note Paragraphs::.)  They also cause Auto Fill mode to use
the definition of TAB to indent the new lines it creates.  This is
because most lines in a program are usually indented.  (*Note
Indentation::.)
* Menu:
* Choosing Modes::     How major modes are specified or chosen.
File: emacs,  Node: Choosing Modes,  Prev: Major Modes,  Up: Major Modes
How Major Modes are Chosen
==========================
   You can select a major mode explicitly for the current buffer, but
most of the time Emacs determines which mode to use based on the file
name or on special text in the file.
   Explicit selection of a new major mode is done with a `M-x' command.
From the name of a major mode, add `-mode' to get the name of a command
to select that mode.  Thus, you can enter Lisp mode by executing `M-x
lisp-mode'.
   When you visit a file, Emacs usually chooses the right major mode
based on the file's name.  For example, files whose names end in `.c'
are edited in C mode.  The correspondence between file names and major
mode is controlled by the variable `auto-mode-alist'.  Its value is a
list in which each element has the form
     (REGEXP . MODE-FUNCTION)
For example, one element normally found in the list has the form
`("\\.c$" . c-mode)', and it is responsible for selecting C mode for
files whose names end in `.c'.  (Note that `\\' is needed in Lisp
syntax to include a `\' in the string, which is needed to suppress the
special meaning of `.' in regexps.)  The only practical way to change
this variable is with Lisp code.
   You can specify which major mode should be used for editing a certain
file by a special sort of text in the first nonblank line of the file.
The mode name should appear in this line both preceded and followed by
`-*-'.  Other text may appear on the line as well.  For example,
     ;-*-Lisp-*-
tells Emacs to use Lisp mode.  Such an explicit specification overrides
any defaulting based on the file name.  Note how the semicolon is used
to make Lisp treat this line as a comment.
   Another format of mode specification is
     -*-Mode: MODENAME;-*-
which allows you to specify local variables as well, like this:
     -*- mode: MODENAME; VAR: VALUE; ... -*-
*Note File Variables::, for more information about this.
   When you visit a file that does not specify a major mode to use, or
when you create a new buffer with `C-x b', the variable
`default-major-mode' specifies which major mode to use.  Normally its
value is the symbol `fundamental-mode', which specifies Fundamental
mode.  If `default-major-mode' is `nil', the major mode is taken from
the previously selected buffer.
   If you change the major mode of a buffer, you can go back to the
major mode Emacs would choose automatically: use the command `M-x
normal-mode' to do this.  This is the same function that `find-file'
calls to choose the major mode.  It also processes the file's local
variables list if any.
File: emacs,  Node: Indentation,  Next: Text,  Prev: Major Modes,  Up: Top
Indentation
***********
   This chapter describes the Emacs commands that add, remove, or
adjust indentation.
`TAB'
     Indent current line "appropriately" in a mode-dependent fashion.
`LFD'
     Perform RET followed by TAB (`newline-and-indent').
`M-^'
     Merge two lines (`delete-indentation').  This would cancel out the
     effect of LFD.
`C-M-o'
     Split line at point; text on the line after point becomes a new
     line indented to the same column that it now starts in
     (`split-line').
`M-m'
     Move (forward or back) to the first nonblank character on the
     current line (`back-to-indentation').
`C-M-\'
     Indent several lines to same column (`indent-region').
`C-x TAB'
     Shift block of lines rigidly right or left (`indent-rigidly').
`M-i'
     Indent from point to the next prespecified tab stop column
     (`tab-to-tab-stop').
`M-x indent-relative'
     Indent from point to under an indentation point in the previous
     line.
   Most programming languages have some indentation convention.  For
Lisp code, lines are indented according to their nesting in
parentheses.  The same general idea is used for C code, though many
details are different.
   Whatever the language, to indent a line, use the TAB command.  Each
major mode defines this command to perform the sort of indentation
appropriate for the particular language.  In Lisp mode, TAB aligns the
line according to its depth in parentheses.  No matter where in the
line you are when you type TAB, it aligns the line as a whole.  In C
mode, TAB implements a subtle and sophisticated indentation style that
knows about many aspects of C syntax.
   In Text mode, TAB runs the command `tab-to-tab-stop', which indents
to the next tab stop column.  You can set the tab stops with `M-x
edit-tab-stops'.
* Menu:
* Indentation Commands::  Various commands and techniques for indentation.
* Tab Stops::             You can set arbitrary "tab stops" and then
                            indent to the next tab stop when you want to.
* Just Spaces::           You can request indentation using just spaces.
File: emacs,  Node: Indentation Commands,  Next: Tab Stops,  Prev: Indentation,  Up: Indentation
Indentation Commands and Techniques
===================================
   If you just want to insert a tab character in the buffer, you can
type `C-q TAB'.
   To move over the indentation on a line, do `M-m'
(`back-to-indentation').  This command, given anywhere on a line,
positions point at the first nonblank character on the line.
   To insert an indented line before the current line, do `C-a C-o
TAB'.  To make an indented line after the current line, use `C-e LFD'.
   `C-M-o' (`split-line') moves the text from point to the end of the
line vertically down, so that the current line becomes two lines.
`C-M-o' first moves point forward over any spaces and tabs.  Then it
inserts after point a newline and enough indentation to reach the same
column point is on.  Point remains before the inserted newline; in this
regard, `C-M-o' resembles `C-o'.
   To join two lines cleanly, use the `M-^' (`delete-indentation')
command.  It deletes the indentation at the front of the current line,
and the line boundary as well, replacing them with a single space.  As
a special case (useful for Lisp code) the single space is omitted if
the characters to be joined are consecutive open parentheses or closing
parentheses, or if the junction follows another newline.  To delete
just the indentation of a line, go to the beginning of the line and use
`M-\' (`delete-horizontal-space'), which deletes all spaces and tabs
around the cursor.
   If you have a fill prefix, `M-^' deletes the fill prefix if it
appears after the newline that is deleted.  *Note Fill Prefix::.
   There are also commands for changing the indentation of several
lines at once.  `C-M-\' (`indent-region') gives each line which begins
in the region the "usual" indentation by invoking TAB at the beginning
of the line.  A numeric argument specifies the column to indent to, and
each line is shifted left or right so that its first nonblank character
appears in that column.  `C-x TAB' (`indent-rigidly') moves all of the
lines in the region right by its argument (left, for negative
arguments).  The whole group of lines moves rigidly sideways, which is
how the command gets its name.
   `M-x indent-relative' indents at point based on the previous line
(actually, the last nonempty line).  It inserts whitespace at point,
moving point, until it is underneath an indentation point in the
previous line.  An indentation point is the end of a sequence of
whitespace or the end of the line.  If point is farther right than any
indentation point in the previous line, the whitespace before point is
deleted and the first indentation point then applicable is used.  If no
indentation point is applicable even then, `indent-relative' runs
`tab-to-tab-stop' (*note Tab Stops::.).
   `indent-relative' is the definition of TAB in Indented Text mode.
*Note Text::.
File: emacs,  Node: Tab Stops,  Next: Just Spaces,  Prev: Indentation Commands,  Up: Indentation
Tab Stops
=========
   For typing in tables, you can use Text mode's definition of TAB,
`tab-to-tab-stop'.  This command inserts indentation before point,
enough to reach the next tab stop column.  If you are not in Text mode,
this command can be found on the key `M-i'.
   You can specify the tab stops used by `M-i'.  They are stored in a
variable called `tab-stop-list', as a list of column-numbers in
increasing order.
   The convenient way to set the tab stops is with `M-x edit-tab-stops',
which creates and selects a buffer containing a description of the tab
stop settings.  You can edit this buffer to specify different tab
stops, and then type `C-c C-c' to make those new tab stops take effect.
In the tab stop buffer, `C-c C-c' runs the function
`edit-tab-stops-note-changes' rather than its usual definition
`save-buffer'.  `edit-tab-stops' records which buffer was current when
you invoked it, and stores the tab stops back in that buffer; normally
all buffers share the same tab stops and changing them in one buffer
affects all, but if you happen to make `tab-stop-list' local in one
buffer then `edit-tab-stops' in that buffer will edit the local
settings.
   Here is what the text representing the tab stops looks like for
ordinary tab stops every eight columns.
             :       :       :       :       :       :
     0         1         2         3         4
     0123456789012345678901234567890123456789012345678
     To install changes, type C-c C-c
   The first line contains a colon at each tab stop.  The remaining
lines are present just to help you see where the colons are and know
what to do.
   Note that the tab stops that control `tab-to-tab-stop' have nothing
to do with displaying tab characters in the buffer.  *Note Display
Vars::, for more information on that.
File: emacs,  Node: Just Spaces,  Prev: Tab Stops,  Up: Indentation
Tabs vs. Spaces
===============
   Emacs normally uses both tabs and spaces to indent lines.  If you
prefer, all indentation can be made from spaces only.  To request this,
set `indent-tabs-mode' to `nil'.  This is a per-buffer variable;
altering the variable affects only the current buffer, but there is a
default value which you can change as well.  *Note Locals::.
   There are also commands to convert tabs to spaces or vice versa,
always preserving the columns of all nonblank text.  `M-x tabify' scans
the region for sequences of spaces, and converts sequences of at least
three spaces to tabs if that can be done without changing indentation.
`M-x untabify' changes all tabs in the region to appropriate numbers of
spaces.
File: emacs,  Node: Text,  Next: Programs,  Prev: Indentation,  Up: Top
Commands for Human Languages
****************************
   The term "text" has two widespread meanings in our area of the
computer field.  One is data that is a sequence of characters.  Any file
that you edit with Emacs is text, in this sense of the word.  The other
meaning is more restrictive: a sequence of characters in a human
language for humans to read (possibly after processing by a text
formatter), as opposed to a program or commands for a program.
   Human languages have syntactic/stylistic conventions that can be
supported or used to advantage by editor commands: conventions involving
words, sentences, paragraphs, and capital letters.  This chapter
describes Emacs commands for all of these things.  There are also
commands for "filling", which means rearranging the lines of a
paragraph to be approximately equal in length.  The commands for moving
over and killing words, sentences and paragraphs, while intended
primarily for editing text, are also often useful for editing programs.
   Emacs has several major modes for editing human language text.  If
the file contains text pure and simple, use Text mode, which customizes
Emacs in small ways for the syntactic conventions of text.  For text
which contains embedded commands for text formatters, Emacs has other
major modes, each for a particular text formatter.  Thus, for input to
TeX, you would use TeX mode; for input to nroff, Nroff mode.
* Menu:
* Words::         Moving over and killing words.
* Sentences::     Moving over and killing sentences.
* Paragraphs::      Moving over paragraphs.
* Pages::      Moving over pages.
* Filling::       Filling or justifying text.
* Case::          Changing the case of text.
* Text Mode::     The major modes for editing text files.
* Outline Mode::  The major mode for editing outlines.
* TeX Mode::      The major modes for editing input to the formatter TeX.
* Nroff Mode::    The major mode for editing input to the formatter nroff.
File: emacs,  Node: Words,  Next: Sentences,  Up: Text
Words
=====
   Emacs has commands for moving over or operating on words.  By
convention, the keys for them are all Meta characters.
`M-f'
     Move forward over a word (`forward-word').
`M-b'
     Move backward over a word (`backward-word').
`M-d'
     Kill up to the end of a word (`kill-word').
`M-DEL'
     Kill back to the beginning of a word (`backward-kill-word').
`M-@'
     Mark the end of the next word (`mark-word').
`M-t'
     Transpose two words or drag a word across other words
     (`transpose-words').
   Notice how these keys form a series that parallels the
character-based `C-f', `C-b', `C-d', `C-t' and DEL.  `M-@' is related
to `C-@', which is an alias for `C-SPC'.
   The commands `M-f' (`forward-word') and `M-b' (`backward-word') move
forward and backward over words.  These Meta characters are thus
analogous to the corresponding control characters, `C-f' and `C-b',
which move over single characters in the text.  The analogy extends to
numeric arguments, which serve as repeat counts.  `M-f' with a negative
argument moves backward, and `M-b' with a negative argument moves
forward.  Forward motion stops right after the last letter of the word,
while backward motion stops right before the first letter.
   `M-d' (`kill-word') kills the word after point.  To be precise, it
kills everything from point to the place `M-f' would move to.  Thus, if
point is in the middle of a word, `M-d' kills just the part after
point.  If some punctuation comes between point and the next word, it
is killed along with the word.  (If you wish to kill only the next word
but not the punctuation before it, simply do `M-f' to get the end, and
kill the word backwards with `M-DEL'.) `M-d' takes arguments just like
`M-f'.
   `M-DEL' (`backward-kill-word') kills the word before point.  It
kills everything from point back to where `M-b' would move to.  If
point is after the space in `FOO, BAR', then `FOO, ' is killed.  (If
you wish to kill just `FOO', do `M-b M-d' instead of `M-DEL'.)
   `M-t' (`transpose-words') exchanges the word before or containing
point with the following word.  The delimiter characters between the
words do not move.  For example, `FOO, BAR' transposes into `BAR, FOO'
rather than `BAR FOO,'.  *Note Transpose::, for more on transposition
and on arguments to transposition commands.
   To operate on the next N words with an operation which applies
between point and mark, you can either set the mark at point and then
move over the words, or you can use the command `M-@' (`mark-word')
which does not move point, but sets the mark where `M-f' would move to.
`M-@' accepts a numeric argument that says how many words to scan for
the place to put the mark.
   The word commands' understanding of syntax is completely controlled
by the syntax table.  Any character can, for example, be declared to be
a word delimiter.  *Note Syntax::.
File: emacs,  Node: Sentences,  Next: Paragraphs,  Prev: Words,  Up: Text
Sentences
=========
   The Emacs commands for manipulating sentences and paragraphs are
mostly on Meta keys, so as to be like the word-handling commands.
`M-a'
     Move back to the beginning of the sentence (`backward-sentence').
`M-e'
     Move forward to the end of the sentence (`forward-sentence').
`M-k'
     Kill forward to the end of the sentence (`kill-sentence').
`C-x DEL'
     Kill back to the beginning of the sentence
     (`backward-kill-sentence').
   The commands `M-a' and `M-e' (`backward-sentence' and
`forward-sentence') move to the beginning and end of the current
sentence, respectively.  They were chosen to resemble `C-a' and `C-e',
which move to the beginning and end of a line.  Unlike them, `M-a' and
`M-e' if repeated or given numeric arguments move over successive
sentences.  Emacs assumes that the typist's convention is followed, and
thus considers a sentence to end wherever there is a `.', `?' or `!'
followed by the end of a line or two spaces, with any number of `)',
`]', `'', or `"' characters allowed in between.  A sentence also begins
or ends wherever a paragraph begins or ends.
   Neither `M-a' nor `M-e' moves past the newline or spaces beyond the
sentence edge at which it is stopping.
   Just as `C-a' and `C-e' have a kill command, `C-k', to go with them,
so `M-a' and `M-e' have a corresponding kill command `M-k'
(`kill-sentence') which kills from point to the end of the sentence.
With minus one as an argument it kills back to the beginning of the
sentence.  Larger arguments serve as a repeat count.
   There is a special command, `C-x DEL' (`backward-kill-sentence') for
killing back to the beginning of a sentence, because this is useful
when you change your mind in the middle of composing text.
   The variable `sentence-end' controls recognition of the end of a
sentence.  It is a regexp that matches the last few characters of a
sentence, together with the whitespace following the sentence.  Its
normal value is
     "[.?!][]\"')]*\\($\\|\t\\|  \\)[ \t\n]*"
This example is explained in the section on regexps.  *Note Regexps::.
File: emacs,  Node: Paragraphs,  Next: Pages,  Prev: Sentences,  Up: Text
Paragraphs
==========
   The Emacs commands for manipulating paragraphs are also Meta keys.
`M-{'
     Move back to previous paragraph beginning (`backward-paragraph').
`M-}'
     Move forward to next paragraph end (`forward-paragraph').
`M-h'
     Put point and mark around this or next paragraph
     (`mark-paragraph').
   `M-{' moves to the beginning of the current or previous paragraph,
while `M-}' moves to the end of the current or next paragraph.  Blank
lines and text formatter command lines separate paragraphs and are not
part of any paragraph.  Also, an indented line starts a new paragraph.
   In major modes for programs (as opposed to Text mode), paragraphs
begin and end only at blank lines.  This makes the paragraph commands
continue to be useful even though there are no paragraphs per se.
   When there is a fill prefix, then paragraphs are delimited by all
lines which don't start with the fill prefix.  *Note Filling::.
   When you wish to operate on a paragraph, you can use the command
`M-h' (`mark-paragraph') to set the region around it.  This command
puts point at the beginning and mark at the end of the paragraph point
was in.  If point is between paragraphs (in a run of blank lines, or at
a boundary), the paragraph following point is surrounded by point and
mark.  If there are blank lines preceding the first line of the
paragraph, one of these blank lines is included in the region.  Thus,
for example, `M-h C-w' kills the paragraph around or after point.
   The precise definition of a paragraph boundary is controlled by the
variables `paragraph-separate' and `paragraph-start'.  The value of
`paragraph-start' is a regexp that should match any line that either
starts or separates paragraphs.  The value of `paragraph-separate' is
another regexp that should match only lines that separate paragraphs
without being part of any paragraph.  Lines that start a new paragraph
and are contained in it must match both regexps.  For example, normally
`paragraph-start' is `"^[ \t\n\f]"' and `paragraph-separate' is `"^[
\t\f]*$"'.
   Normally it is desirable for page boundaries to separate paragraphs.
The default values of these variables recognize the usual separator for
pages.
File: emacs,  Node: Pages,  Next: Filling,  Prev: Paragraphs,  Up: Text
Pages
=====
   Files are often thought of as divided into "pages" by the "formfeed"
character (ASCII control-L, octal code 014).  For example, if a file is
printed on a line printer, each page of the file, in this sense, will
start on a new page of paper.  Emacs treats a page-separator character
just like any other character.  You can insert it with `C-q C-l', or
delete it with DEL.  Thus, you are free to paginate your file or not.
However, since pages are often meaningful divisions of the file, Emacs
provides commands to move over them and operate on them.
`C-x ['
     Move point to previous page boundary (`backward-page').
`C-x ]'
     Move point to next page boundary (`forward-page').
`C-x C-p'
     Put point and mark around this page (or another page)
     (`mark-page').
`C-x l'
     Count the lines in this page (`count-lines-page').
   The `C-x [' (`backward-page') command moves point to immediately
after the previous page delimiter.  If point is already right after a
page delimiter, it skips that one and stops at the previous one.  A
numeric argument serves as a repeat count.  The `C-x ]' (`forward-page')
command moves forward past the next page delimiter.
   The `C-x C-p' command (`mark-page') puts point at the beginning of
the current page and the mark at the end.  The page delimiter at the end
is included (the mark follows it).  The page delimiter at the front is
excluded (point follows it).  This command can be followed by `C-w' to
kill a page which is to be moved elsewhere.  If it is inserted after a
page delimiter, at a place where `C-x ]' or `C-x [' would take you, then
the page will be properly delimited before and after once again.
   A numeric argument to `C-x C-p' is used to specify which page to go
to, relative to the current one.  Zero means the current page.  One
means the next page, and -1 means the previous one.
   The `C-x l' command (`count-lines-page') is good for deciding where
to break a page in two.  It prints in the echo area the total number of
lines in the current page, and then divides it up into those preceding
the current line and those following, as in
     Page has 96 (72+25) lines
Notice that the sum is off by one; this is correct if point is not at
the beginning of a line.
   The variable `page-delimiter' controls where pages begin.  Its value
is a regexp that matches the beginning of a line that separates pages.
The normal value of this variable is `"^\f"', which matches a formfeed
character at the beginning of a line.
File: emacs,  Node: Filling,  Next: Case,  Prev: Pages,  Up: Text
Filling Text
============
   With Auto Fill mode, text can be "filled" (broken up into lines that
fit in a specified width) as you insert it.  If you alter existing text
it may no longer be properly filled; then you can use the explicit fill
commands to fill the paragraph again.
* Menu:
* Auto Fill::       Auto Fill mode breaks long lines automatically.
* Fill Commands::  Commands to refill paragraphs and center lines.
* Fill Prefix::    Filling when every line is indented or in a comment, etc.
File: emacs,  Node: Auto Fill,  Next: Fill Commands,  Up: Filling
Auto Fill Mode
--------------
   "Auto Fill" mode is a minor mode in which lines are broken
automatically when they become too wide.  Breaking happens only when
you type a SPC or RET.
`M-x auto-fill-mode'
     Enable or disable Auto Fill mode.
`SPC'
`RET'
     In Auto Fill mode, break lines when appropriate.
   `M-x auto-fill-mode' turns Auto Fill mode on if it was off, or off if
it was on.  With a positive numeric argument it always turns Auto Fill
mode on, and with a negative argument always turns it off.  You can see
when Auto Fill mode is in effect by the presence of the word `Fill' in
the mode line, inside the parentheses.  Auto Fill mode is a minor mode,
turned on or off for each buffer individually.  *Note Minor Modes::.
   In Auto Fill mode, lines are broken automatically at spaces when
they get longer than the desired width.  Line breaking and
rearrangement takes place only when you type SPC or RET.  If you wish
to insert a space or newline without permitting line-breaking, type
`C-q SPC' or `C-q LFD' (recall that a newline is really a linefeed).
Also, `C-o' inserts a newline without line breaking.
   Auto Fill mode works well with Lisp mode, because when it makes a new
line in Lisp mode it indents that line with TAB.  If a line ending in a
comment gets too long, the text of the comment is split into two
comment lines.  Optionally new comment delimiters are inserted at the
end of the first line and the beginning of the second so that each line
is a separate comment; the variable `comment-multi-line' controls the
choice (*note Comments::.).
   Auto Fill mode does not refill entire paragraphs.  It can break
lines but cannot merge lines.  So editing in the middle of a paragraph
can result in a paragraph that is not correctly filled.  The easiest
way to make the paragraph properly filled again is usually with the
explicit fill commands.  *Note Fill Commands::.
   Many users like Auto Fill mode and want to use it in all text files.
The section on init files says how to arrange this permanently for
yourself.  *Note Init File::.
File: emacs,  Node: Fill Commands,  Next: Fill Prefix,  Prev: Auto Fill,  Up: Filling
Explicit Fill Commands
----------------------
`M-q'
     Fill current paragraph (`fill-paragraph').
`C-x f'
     Set the fill column (`set-fill-column').
`M-x fill-region'
     Fill each paragraph in the region (`fill-region').
`M-x fill-region-as-paragraph.'
     Fill the region, considering it as one paragraph.
`M-s'
     Center a line.
   To refill a paragraph, use the command `M-q' (`fill-paragraph').
This operates on the paragraph that point is inside, or the one after
point if point is between paragraphs.  Refilling works by removing all
the line-breaks, then inserting new ones where necessary.
   The command `M-s' (`center-line') centers the current line within
the current fill column.  With an argument, it centers several lines
individually and moves past them.
   To refill many paragraphs, use `M-x fill-region', which divides the
region into paragraphs and fills each of them.
   `M-q' and `fill-region' use the same criteria as `M-h' for finding
paragraph boundaries (*note Paragraphs::.).  For more control, you can
use `M-x fill-region-as-paragraph', which refills everything between
point and mark.  This command deletes any blank lines within the
region, so separate blocks of text end up combined into one block.
   A numeric argument to `M-q' causes it to "justify" the text as well
as filling it.  This means that extra spaces are inserted to make the
right margin line up exactly at the fill column.  To remove the extra
spaces, use `M-q' with no argument.  (Likewise for `fill-region'.)
   When ADAPTIVE-FILL-MODE is non-`nil' (which is normally the case),
if you use `fill-region-as-paragraph' on an indented paragraph and you
don't have a fill prefix, it uses the indentation of the second line of
the paragraph as the fill prefix.  The effect of adaptive filling is
not noticeable in Text mode, because an indented line counts as a
paragraph starter and thus each line of an indented paragraph is
considered a paragraph of its own.  But you do notice the effect in
Indented Text mode and some other major modes.
   The maximum line width for filling is in the variable `fill-column'.
Altering the value of `fill-column' makes it local to the current
buffer; until that time, the default value is in effect.  The default is
initially 70.  *Note Locals::.
   The easiest way to set `fill-column' is to use the command `C-x f'
(`set-fill-column').  With no argument, it sets `fill-column' to the
current horizontal position of point.  With a numeric argument, it uses
that as the new fill column.
File: emacs,  Node: Fill Prefix,  Prev: Fill Commands,  Up: Filling
The Fill Prefix
---------------
   To fill a paragraph in which each line starts with a special marker
(which might be a few spaces, giving an indented paragraph), use the
"fill prefix" feature.  The fill prefix is a string which Emacs expects
every line to start with, and which is not included in filling.
`C-x .'
     Set the fill prefix (`set-fill-prefix').
`M-q'
     Fill a paragraph using current fill prefix (`fill-paragraph').
`M-x fill-individual-paragraphs'
     Fill the region, considering each change of indentation as
     starting a new paragraph.
`M-x fill-nonuniform-paragraphs'
     Fill the region, considering only paragraph-separator lines as
     starting a new paragraph.
   To specify a fill prefix, move to a line that starts with the desired
prefix, put point at the end of the prefix, and give the command
`C-x .' (`set-fill-prefix').  That's a period after the `C-x'.  To turn
off the fill prefix, specify an empty prefix: type `C-x .' with point
at the beginning of a line.
   When a fill prefix is in effect, the fill commands remove the fill
prefix from each line before filling and insert it on each line after
filling.  The fill prefix is also inserted on new lines made
automatically by Auto Fill mode.  Lines that do not start with the fill
prefix are considered to start paragraphs, both in `M-q' and the
paragraph commands; this is just right if you are using paragraphs with
hanging indentation (every line indented except the first one).  Lines
which are blank or indented once the prefix is removed also separate or
start paragraphs; this is what you want if you are writing
multi-paragraph comments with a comment delimiter on each line.
   For example, if `fill-column' is 40 and you set the fill prefix to
`;; ', then `M-q' in the following text
     ;; This is an
     ;; example of a paragraph
     ;; inside a Lisp-style comment.
produces this:
     ;; This is an example of a paragraph
     ;; inside a Lisp-style comment.
   The `C-o' command inserts the fill prefix on new lines it creates,
when you use it at the beginning of a line (*note Blank Lines::.).
Conversely, the command `M-^' deletes the prefix (if it occurs) after
the newline that it deletes (*note Indentation::.).
   You can use `M-x fill-individual-paragraphs' to set the fill prefix
for each paragraph automatically.  This command divides the region into
paragraphs, treating every change in the amount of indentation as the
start of a new paragraph, and fills each of these paragraphs.  Thus,
all the lines in one "paragraph" have the same amount of indentation.
That indentation serves as the fill prefix for that paragraph.
   `M-x fill-nonuniform-paragraphs' is a similar command that divides
the region into paragraphs in a different way.  It considers only
paragraph-separating lines (as defined by `paragraph-separate') as
starting a new paragraph.  Since this means that the lines of one
paragraph may have different amounts of indentation, the fill prefix
used is the smallest amount of indentation of any of the lines of the
paragraph.
   The fill prefix is stored in the variable `fill-prefix'.  Its value
is a string, or `nil' when there is no fill prefix.  This is a
per-buffer variable; altering the variable affects only the current
buffer, but there is a default value which you can change as well.
*Note Locals::.
File: emacs,  Node: Case,  Next: Text Mode,  Prev: Filling,  Up: Text
Case Conversion Commands
========================
   Emacs has commands for converting either a single word or any
arbitrary range of text to upper case or to lower case.
`M-l'
     Convert following word to lower case (`downcase-word').
`M-u'
     Convert following word to upper case (`upcase-word').
`M-c'
     Capitalize the following word (`capitalize-word').
`C-x C-l'
     Convert region to lower case (`downcase-region').
`C-x C-u'
     Convert region to upper case (`upcase-region').
   The word conversion commands are the most useful.  `M-l'
(`downcase-word') converts the word after point to lower case, moving
past it.  Thus, repeating `M-l' converts successive words.  `M-u'
(`upcase-word') converts to all capitals instead, while `M-c'
(`capitalize-word') puts the first letter of the word into upper case
and the rest into lower case.  All these commands convert several words
at once if given an argument.  They are especially convenient for
converting a large amount of text from all upper case to mixed case,
because you can move through the text using `M-l', `M-u' or `M-c' on
each word as appropriate, occasionally using `M-f' instead to skip a
word.
   When given a negative argument, the word case conversion commands
apply to the appropriate number of words before point, but do not move
point.  This is convenient when you have just typed a word in the wrong
case: you can give the case conversion command and continue typing.
   If a word case conversion command is given in the middle of a word,
it applies only to the part of the word which follows point.  This is
just like what `M-d' (`kill-word') does.  With a negative argument,
case conversion applies only to the part of the word before point.
   The other case conversion commands are `C-x C-u' (`upcase-region')
and `C-x C-l' (`downcase-region'), which convert everything between
point and mark to the specified case.  Point and mark do not move.
   The region case conversion commands `upcase-region' and
`downcase-region' are normally disabled.  This means that they ask for
confirmation if you try to use them.  When you confirm, you may enable
the command, which means it will not ask for confirmation again.  *Note
Disabling::.
File: emacs,  Node: Text Mode,  Next: Outline Mode,  Prev: Case,  Up: Text
Text Mode
=========
   When you edit files of text in a human language, it's more convenient
to use Text mode rather than Fundamental mode.  Invoke `M-x text-mode'
to enter Text mode.  In Text mode, TAB runs the function
`tab-to-tab-stop', which allows you to use arbitrary tab stops set with
`M-x edit-tab-stops' (*note Tab Stops::.).  Features concerned with
comments in programs are turned off except when explicitly invoked.
The syntax table is changed so that periods are not considered part of
a word, while apostrophes, backspaces and underlines are.
   A similar variant mode is Indented Text mode, intended for editing
text in which most lines are indented.  This mode defines TAB to run
`indent-relative' (*note Indentation::.), and makes Auto Fill indent
the lines it creates.  The result is that normally a line made by Auto
Filling, or by LFD, is indented just like the previous line.  Use `M-x
indented-text-mode' to select this mode.
   Entering Text mode or Indented Text mode runs the hook
`text-mode-hook'.  Other major modes related to Text mode also run this
hook, followed by hooks of their own; this includes Nroff mode, TeX
mode, Outline mode and Mail mode.  Hook functions on `text-mode-hook'
can look at the value of `major-mode' to see which of these modes is
actually being entered.  *Note Hooks::.
* Menu:
  Two modes similar to Text mode are of use for editing text that is to
be passed through a text formatter before achieving the form in which
humans are to read it.
* Nroff Mode::  The major mode for editing input to the formatter nroff.
* TeX Mode::    The major modes for editing input to the formatter TeX.
  Another similar mode is used for editing outlines.  It allows you
to view the text at various levels of detail.  You can view either
the outline headings alone or both headings and text; you can also
hide some of the headings at lower levels from view to make the high
level structure more visible.
* Outline Mode::The major mode for editing outlines.
File: emacs,  Node: Outline Mode,  Next: TeX Mode,  Prev: Text Mode,  Up: Text
Outline Mode
============
   Outline mode is a major mode much like Text mode but intended for
editing outlines.  It allows you to make parts of the text temporarily
invisible so that you can see just the overall structure of the
outline.  Type `M-x outline-mode' to switch to Outline mode as the
major mode of the current buffer.  Type `M-x outline-minor-mode' to
enable Outline mode as a minor mode in the current buffer.  When
Outline minor mode is enabled, the `C-c' commands of Outline mode
replace those of the major mode.
   When a line is invisible in outline mode, it does not appear on the
screen.  The screen appears exactly as if the invisible line were
deleted, except that an ellipsis (three periods in a row) appears at
the end of the previous visible line (only one ellipsis no matter how
many invisible lines follow).
   All editing commands treat the text of the invisible line as part of
the previous visible line.  For example, `C-n' moves onto the next
visible line.  Killing an entire visible line, including its
terminating newline, really kills all the following invisible lines
along with it; yanking it all back yanks the invisible lines and they
remain invisible.
   Entering Outline mode runs the hook `text-mode-hook' followed by the
hook `outline-mode-hook' (*note Hooks::.).
* Menu:
* Format: Outline Format.       What the text of an outline looks like.
* Motion: Outline Motion.       Special commands for moving through
                                     outlines.
* Visibility: Outline Visibility.  Commands to control what is visible.
File: emacs,  Node: Outline Format,  Next: Outline Motion,  Up: Outline Mode
Format of Outlines
------------------
   Outline mode assumes that the lines in the buffer are of two types:
"heading lines" and "body lines".  A heading line represents a topic in
the outline.  Heading lines start with one or more stars; the number of
stars determines the depth of the heading in the outline structure.
Thus, a heading line with one star is a major topic; all the heading
lines with two stars between it and the next one-star heading are its
subtopics; and so on.  Any line that is not a heading line is a body
line.  Body lines belong with the preceding heading line.  Here is an
example:
     * Food

     This is the body,
     which says something about the topic of food.

     ** Delicious Food

     This is the body of the second-level header.

     ** Distasteful Food

     This could have
     a body too, with
     several lines.

     *** Dormitory Food

     * Shelter

     A second first-level topic with its header line.
   A heading line together with all following body lines is called
collectively an "entry".  A heading line together with all following
deeper heading lines and their body lines is called a "subtree".
   You can customize the criterion for distinguishing heading lines by
setting the variable `outline-regexp'.  Any line whose beginning has a
match for this regexp is considered a heading line.  Matches that start
within a line (not at the beginning) do not count.  The length of the
matching text determines the level of the heading; longer matches make
a more deeply nested level.  Thus, for example, if a text formatter has
commands `@chapter', `@section' and `@subsection' to divide the
document into chapters and sections, you could make those lines count
as heading lines by setting `outline-regexp' to
`"@chap\\|@\\(sub\\)*section"'.  Note the trick: the two words
`chapter' and `section' are equally long, but by defining the regexp to
match only `chap' we ensure that the length of the text matched on a
chapter heading is shorter, so that Outline mode will know that
sections are contained in chapters.  This works as long as no other
command starts with `@chap'.
   Outline mode makes a line invisible by changing the newline before it
into an ASCII control-M (code 015).  Most editing commands that work on
lines treat an invisible line as part of the previous line because,
strictly speaking, it *is* part of that line, since there is no longer a
newline in between.  When you save the file in Outline mode, control-M
characters are saved as newlines, so the invisible lines become ordinary
lines in the file.  But saving does not change the visibility status of
a line inside Emacs.
File: emacs,  Node: Outline Motion,  Next: Outline Visibility,  Prev: Outline Format,  Up: Outline Mode
Outline Motion Commands
-----------------------
   There are some special motion commands in Outline mode that move
backward and forward to heading lines.
`C-c C-n'
     Move point to the next visible heading line
     (`outline-next-visible-heading').
`C-c C-p'
     Move point to the previous visible heading line
     (`outline-previous-visible-heading').
`C-c C-f'
     Move point to the next visible heading line at the same level as
     the one point is on (`outline-forward-same-level').
`C-c C-b'
     Move point to the previous visible heading line at the same level
     (`outline-backward-same-level').
`C-c C-u'
     Move point up to a lower-level (more inclusive) visible heading
     line (`outline-up-heading').
   `C-c C-n' (`next-visible-heading') moves down to the next heading
line.  `C-c C-p' (`previous-visible-heading') moves similarly backward.
Both accept numeric arguments as repeat counts.  The names emphasize
that invisible headings are skipped, but this is not really a special
feature.  All editing commands that look for lines ignore the invisible
lines automatically.
   More powerful motion commands understand the level structure of
headings.  `C-c C-f' (`outline-forward-same-level') and `C-c C-b'
(`outline-backward-same-level') move from one heading line to another
visible heading at the same depth in the outline.  `C-c C-u'
(`outline-up-heading') moves backward to another heading that is less
deeply nested.